home *** CD-ROM | disk | FTP | other *** search
/ Total Network Tools 2002 / NextStepPublishing-TotalNetworkTools2002-Win95.iso / Archive / Misc Servers / Zope.exe / XMLTOOLS.PY < prev    next >
Encoding:
Python Source  |  2000-05-04  |  13.5 KB  |  432 lines
  1. ##############################################################################
  2. # 
  3. # Zope Public License (ZPL) Version 1.0
  4. # -------------------------------------
  5. # 
  6. # Copyright (c) Digital Creations.  All rights reserved.
  7. # 
  8. # This license has been certified as Open Source(tm).
  9. # 
  10. # Redistribution and use in source and binary forms, with or without
  11. # modification, are permitted provided that the following conditions are
  12. # met:
  13. # 
  14. # 1. Redistributions in source code must retain the above copyright
  15. #    notice, this list of conditions, and the following disclaimer.
  16. # 
  17. # 2. Redistributions in binary form must reproduce the above copyright
  18. #    notice, this list of conditions, and the following disclaimer in
  19. #    the documentation and/or other materials provided with the
  20. #    distribution.
  21. # 
  22. # 3. Digital Creations requests that attribution be given to Zope
  23. #    in any manner possible. Zope includes a "Powered by Zope"
  24. #    button that is installed by default. While it is not a license
  25. #    violation to remove this button, it is requested that the
  26. #    attribution remain. A significant investment has been put
  27. #    into Zope, and this effort will continue if the Zope community
  28. #    continues to grow. This is one way to assure that growth.
  29. # 
  30. # 4. All advertising materials and documentation mentioning
  31. #    features derived from or use of this software must display
  32. #    the following acknowledgement:
  33. # 
  34. #      "This product includes software developed by Digital Creations
  35. #      for use in the Z Object Publishing Environment
  36. #      (http://www.zope.org/)."
  37. # 
  38. #    In the event that the product being advertised includes an
  39. #    intact Zope distribution (with copyright and license included)
  40. #    then this clause is waived.
  41. # 
  42. # 5. Names associated with Zope or Digital Creations must not be used to
  43. #    endorse or promote products derived from this software without
  44. #    prior written permission from Digital Creations.
  45. # 
  46. # 6. Modified redistributions of any form whatsoever must retain
  47. #    the following acknowledgment:
  48. # 
  49. #      "This product includes software developed by Digital Creations
  50. #      for use in the Z Object Publishing Environment
  51. #      (http://www.zope.org/)."
  52. # 
  53. #    Intact (re-)distributions of any official Zope release do not
  54. #    require an external acknowledgement.
  55. # 
  56. # 7. Modifications are encouraged but must be packaged separately as
  57. #    patches to official Zope releases.  Distributions that do not
  58. #    clearly separate the patches from the original work must be clearly
  59. #    labeled as unofficial distributions.  Modifications which do not
  60. #    carry the name Zope may be packaged in any form, as long as they
  61. #    conform to all of the clauses above.
  62. # 
  63. # 
  64. # Disclaimer
  65. # 
  66. #   THIS SOFTWARE IS PROVIDED BY DIGITAL CREATIONS ``AS IS'' AND ANY
  67. #   EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  68. #   IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  69. #   PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL DIGITAL CREATIONS OR ITS
  70. #   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  71. #   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  72. #   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  73. #   USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  74. #   ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  75. #   OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  76. #   OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  77. #   SUCH DAMAGE.
  78. # 
  79. # 
  80. # This software consists of contributions made by Digital Creations and
  81. # many individuals on behalf of Digital Creations.  Specific
  82. # attributions are listed in the accompanying credits file.
  83. # 
  84. ##############################################################################
  85.  
  86. """WebDAV XML parsing tools. Note that this module does just
  87.    enough for the purposes of DAV - it is not intended as a
  88.    general xml toolkit, and will probably eventually go away
  89.    in favor of a standard xml package once some issues are
  90.    worked out."""
  91.  
  92. __version__='$Revision: 1.9 $'[11:-2]
  93.  
  94. import sys, os, string
  95. import Shared.DC.xml.xmllib
  96. from Acquisition import Implicit
  97. from cStringIO import StringIO
  98.  
  99.  
  100. type_document=0
  101. type_element=1
  102. type_attribute=2
  103. type_text=3
  104. type_cdata=4
  105. type_entityref=5
  106. type_entity=6
  107. type_procinst=7
  108. type_comment=8
  109. type_notation=9
  110.  
  111.  
  112. class Node(Implicit):
  113.     """Common base class for Node objects."""
  114.     __name__=''
  115.     __value__=''
  116.     __attrs__=[]
  117.     __nodes__=[]
  118.     __nskey__=''
  119.  
  120.     def name(self):  return self.__name__
  121.     def attrs(self): return self.__attrs__
  122.     def value(self): return self.__value__
  123.     def nodes(self): return self.__nodes__
  124.     def nskey(self): return self.__nskey__
  125.     
  126.     def addNode(self, node):
  127.         self.__nodes__.append(node.__of__(self))
  128.  
  129.     def namespace(self):
  130.         nskey=self.__nskey__
  131.         while 1:
  132.             if hasattr(self, '__nsdef__'):
  133.                 val=self.__nsdef__.get(nskey, None)
  134.                 if val is not None: return val
  135.             if not hasattr(self, 'aq_parent'):
  136.                 return ''
  137.             self=self.aq_parent
  138.  
  139.     def elements(self, name=None, ns=None, lower=string.lower):
  140.         nodes=[]
  141.         name=name and lower(name)
  142.         for node in self.__nodes__:
  143.             if node.__type__==type_element and \
  144.                ((name is None) or (lower(node.__name__)==name)) and \
  145.                ((ns is None) or (node.namespace()==ns)):
  146.                 nodes.append(node)
  147.         return nodes
  148.     
  149.     def __getitem__(self, n):
  150.         return self.__nodes__[n]
  151.  
  152.     def qname(self):
  153.         ns=self.__nskey__
  154.         if ns: ns='%s:' % ns
  155.         return '%s%s' % (ns, self.__name__)
  156.  
  157.     def toxml(self):
  158.         return self.__value__
  159.  
  160.     def strval(self):
  161.         return self.toxml()
  162.  
  163.  
  164. class Document(Node):
  165.     def __init__(self, encoding='utf-8', stdalone=''):
  166.         self.__name__ ='document'
  167.         self.__nodes__=[]
  168.         self.encoding=encoding
  169.         self.stdalone=stdalone
  170.         self.document=self
  171.         
  172.     def toxml(self):
  173.         result=['<?xml version="1.0" encoding="%s"?>' % self.encoding]
  174.         for node in self.__nodes__:
  175.             result.append(node.toxml())
  176.         return string.join(result, '')
  177.  
  178.     #def __del__(self):
  179.     #    self.document=None
  180.     #    print 'bye!'
  181.         
  182. class Element(Node):
  183.     __type__=type_element
  184.     
  185.     def __init__(self, name, attrs={}):
  186.         self.__name__ =name
  187.         self.__attrs__=[]
  188.         self.__nodes__=[]
  189.         self.__nsdef__={}
  190.         self.__nskey__=''
  191.         for name, val in attrs.items():
  192.             attr=Attribute(name, val)
  193.             self.__attrs__.append(attr)
  194.         self.ns_parse()
  195.         parts=string.split(self.__name__, ':')
  196.         if len(parts) > 1:
  197.             self.__nskey__=parts[0]
  198.             self.__name__=string.join(parts[1:], ':')
  199.             
  200.     def ns_parse(self):
  201.         nsdef=self.__nsdef__={}
  202.         for attr in self.attrs():
  203.             name, val=attr.name(), attr.value()
  204.             key=string.lower(name)
  205.             if key[:6]=='xmlns:':
  206.                 nsdef[name[6:]]=val
  207.             elif key=='xmlns':
  208.                 nsdef['']=val
  209.  
  210.     def fixup(self):
  211.         self.__attrs__=map(lambda n, s=self: n.__of__(s), self.__attrs__)
  212.         
  213.     def get_attr(self, name, ns=None, default=None):
  214.         for attr in self.__attrs__:
  215.             if attr.name()==name and (ns is None) or (ns==attr.namespace()):
  216.                 return attr
  217.         return default
  218.  
  219.     def del_attr(self, name):
  220.         attrs=[]
  221.         for attr in self.__attrs__:
  222.             if attr.name() != name:
  223.                 attrs.append(attr)
  224.         self.__attrs__=attrs
  225.  
  226.     def remap(self, dict, n=0, top=1):
  227.         # The remap method effectively rewrites an element and all of its
  228.         # children, consolidating namespace declarations into the element
  229.         # on which the remap function is called and fixing up namespace
  230.         # lookup structures.
  231.         nsval=self.namespace()
  232.         if not nsval: nsid=''
  233.         elif not dict.has_key(nsval):
  234.             nsid='ns%d' % n
  235.             dict[nsval]=nsid
  236.             n=n+1
  237.         else: nsid=dict[nsval]
  238.         for attr in self.__attrs__:
  239.             dict, n=attr.remap(dict, n, 0)
  240.         for node in self.elements():
  241.             dict, n=node.remap(dict, n, 0)
  242.         attrs=[]
  243.         for attr in self.__attrs__:
  244.             name=attr.__name__
  245.             if not (((len(name) >= 6) and (name[:6]=='xmlns:')) or \
  246.                     name=='xmlns'):
  247.                 attrs.append(attr)
  248.         self.__attrs__=attrs
  249.         self.__nsdef__={}
  250.         self.__nskey__=nsid
  251.         if top:
  252.             attrs=self.__attrs__
  253.             keys=dict.keys()
  254.             keys.sort()
  255.             for key in keys:
  256.                 attr=Attribute('xmlns:%s' % dict[key], key)
  257.                 attrs.append(attr.__of__(self))
  258.             self.__attrs__=attrs
  259.             self.ns_parse()
  260.         return dict, n
  261.  
  262.     def toxml(self):
  263.         qname=self.qname()
  264.         result=['<%s' % qname]
  265.         for attr in self.__attrs__:
  266.             result.append(attr.toxml())
  267.         if not self.__value__ and not self.__nodes__:
  268.             result.append('/>')
  269.         else:
  270.             result.append('>')
  271.             for node in self.__nodes__:
  272.                 result.append(node.toxml())
  273.             result.append('</%s>' % qname)
  274.         return string.join(result, '')
  275.  
  276.     def strval(self, top=1):
  277.         if not self.__value__ and not self.__nodes__:
  278.             return ''
  279.         result=map(lambda n: n.toxml(), self.__nodes__)
  280.         return string.join(result, '')
  281.  
  282. class Attribute(Node):
  283.     __type__=type_attribute
  284.     def __init__(self, name, val):
  285.         self.__name__=name
  286.         self.__value__=val
  287.         self.__nskey__=''
  288.         parts=string.split(name, ':')
  289.         if len(parts) > 1:
  290.             pre=string.lower(parts[0])
  291.             if not (pre in ('xml', 'xmlns')):
  292.                 self.__nskey__=parts[0]
  293.                 self.__name__=string.join(parts[1:], ':')
  294.  
  295.     def remap(self, dict, n=0, top=1):
  296.         nsval=self.namespace()
  297.         if not nsval: nsid=''
  298.         elif not dict.has_key(nsval):
  299.             nsid='ns%d' % n
  300.             dict[nsval]=nsid
  301.             n=n+1
  302.         else: nsid=dict[nsval]
  303.         self.__nskey__=nsid
  304.         return dict, n
  305.  
  306.     def toxml(self):
  307.         ns=self.__nskey__
  308.         if ns: ns='%s:' % ns
  309.         return ' %s%s="%s"' % (ns, self.__name__, self.__value__)
  310.         
  311. class Text(Node):
  312.     __name__='#text'
  313.     __type__=type_text
  314.     def __init__(self, val):
  315.         self.__value__=val
  316.     def toxml(self):
  317.         return escape(self.__value__)
  318.  
  319. class CData(Node):
  320.     __type__=type_cdata
  321.     __name__='#cdata'
  322.     def __init__(self, val):
  323.         self.__value__=val
  324.     def toxml(self):
  325.         return '<![CDATA[%s]]>' % self.__value__
  326.  
  327. class EntityRef(Node):
  328.     __name__='#entityref'
  329.     __type__=type_entityref
  330.     def __init__(self, val):
  331.         self.__value__=val        
  332.     def toxml(self):
  333.         return '&%s;' % self.__value__
  334.  
  335. class Entity(Node):
  336.     __name__='#entity'
  337.     __type__=type_entity
  338.     def __init__(self, name, pubid, sysid, nname):
  339.         self.__value__=val
  340.     def toxml(self):
  341.         return ''
  342.  
  343. class ProcInst(Node):
  344.     __type__=type_procinst
  345.     def __init__(self, name, val):
  346.         self.__name__=name
  347.         self.__value__=val
  348.     def toxml(self):
  349.         return '<?%s %s?>' % (self.__name__, self.__value__)
  350.  
  351. class Comment(Node):
  352.     __name__='#comment'
  353.     __type__=type_comment
  354.     def __init__(self, val):
  355.         self.__value__=val
  356.     def toxml(self):
  357.         return '<!--%s-->' % self.__value__
  358.  
  359.  
  360.  
  361.  
  362.  
  363. class XmlParser(Shared.DC.xml.xmllib.XMLParser):
  364.     def __init__(self):
  365.         Shared.DC.xml.xmllib.XMLParser.__init__(self)
  366.         self.root=None
  367.         self.node=None
  368.         
  369.     def parse(self, data):
  370.         self.feed(data)
  371.         self.close()
  372.         return self.root
  373.     
  374.     def add(self, node):
  375.         self.node.addNode(node)
  376.  
  377.     def push(self, node):
  378.         self.node.addNode(node)
  379.         self.node=self.node.__nodes__[-1]
  380.  
  381.     def pop(self):
  382.         self.node=self.node.aq_parent
  383.  
  384.     def unknown_starttag(self, name, attrs):
  385.         node=Element(name, attrs)
  386.         self.push(node)
  387.         # Fixup aq chain!
  388.         self.node.fixup()
  389.  
  390.     def unknown_endtag(self, name):
  391.         self.pop()
  392.  
  393.     def handle_xml(self, encoding, stdalone):
  394.         self.root=Document(encoding, stdalone)
  395.         self.node=self.root
  396.  
  397.     def handle_doctype(self, tag, pubid, syslit, data):
  398.         pass
  399.  
  400.     def handle_entity(self, name, strval, pubid, syslit, ndata):
  401.         self.add(Entity(name, strval, pubid, syslit, ndata))
  402.  
  403.     def handle_cdata(self, data):
  404.         self.add(CData(data))
  405.  
  406.     def handle_proc(self, name, data):
  407.         self.add(ProcInst(name, data))
  408.  
  409.     def handle_comment(self, data):
  410.         self.add(Comment(data))
  411.  
  412.     def handle_data(self, data):
  413.         self.add(Text(data))
  414.  
  415.     def unknown_entityref(self, data):
  416.         self.add(EntityRef(data))
  417.  
  418.  
  419.  
  420. def escape(data, rmap={}, replace=string.replace):
  421.     data=replace(data, "&", "&")
  422.     data=replace(data, "<", "<")
  423.     data=replace(data, ">", ">")
  424.     for key, val in rmap.items():
  425.         data=replace(data, key, val)
  426.     return data
  427.  
  428. def remap(data, dict={'DAV:': 'd'}):
  429.     root=XmlParser().parse(data)
  430.     root.elements()[0].remap(dict, 0)
  431.     return root.toxml()
  432.